Load Libraries¶
In [631]:
from PIL import Image # read images
import requests
from io import BytesIO
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from bs4 import BeautifulSoup # web scraping
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
from nltk.stem import PorterStemmer
import nltk
import math
import time
import re
import os
import seaborn as sns
from collections import Counter
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
from sklearn.metrics import pairwise_distances
from matplotlib import gridspec
from scipy.sparse import hstack
import plotly
import plotly.figure_factory as ff
from plotly.graph_objs import Scatter, Layout
import itertools
plotly.offline.init_notebook_mode(connected=True)
import warnings
warnings.filterwarnings("ignore")
Load Dataset¶
In [15]:
data = pd.read_json('tops_fashion.json')
Explore Dataset¶
In [16]:
data.shape
Out[16]:
In [17]:
data.columns
Out[17]:
I will use only 6 features.
1. asin ( Amazon standard identification number)(unique number)
2. brand ( brand to which the product belongs to )
3. color ( Color information of apparel, it can contain many colors as a value ex: red and black stripes )
4. product_type_name (type of the apperal, ex: SHIRT/TSHIRT )
5. medium_image_url ( url of the image )
6. title (title of the product.) (information about products)
7. formatted_price (price of the product)In [18]:
data = data[['asin', 'brand', 'color', 'medium_image_url', 'product_type_name', 'title', 'formatted_price']]
In [19]:
data.head()
Out[19]:
Feature:product_type_name¶
In [20]:
# Count of Products:
data["product_type_name"].nunique()
Out[20]:
In [21]:
# Missng Values Control:
data["product_type_name"].isnull().sum()
Out[21]:
In [22]:
# Percentage of Products: Top 10
data["product_type_name"].value_counts()[:10] # to see percentage:normalize=True
Out[22]:
Feature:brand¶
In [23]:
# Count of Brand:
data["brand"].nunique()
Out[23]:
In [24]:
# Missng Values Control:
data["brand"].isnull().sum()
Out[24]:
In [25]:
# Percentage of Products: Top 10
data["brand"].value_counts()[:10]
Out[25]:
Feature:color¶
In [26]:
# Count of Color:
data["color"].nunique()
Out[26]:
In [27]:
# Missng Values Control:
data["color"].isnull().sum()
Out[27]:
In [28]:
# Percentage of Products: Top 10
data["color"].value_counts()[:10]
Out[28]:
Feature:formatted_price¶
In [29]:
# Missng Values Control:
data["formatted_price"].isnull().sum()
Out[29]:
In [30]:
# Percentage of Price Is NOT missing:
((len(data["formatted_price"]) - data["formatted_price"].isnull().sum()) / len(data["formatted_price"])) * 100
Out[30]:
In [31]:
data["formatted_price"].describe()
Out[31]:
Feature:title¶
In [32]:
# very good count of title
data["title"].describe()
Out[32]:
Prepare Dataset¶
In [33]:
# Make a copy of dataset
data2 = data.copy()
In [34]:
# Drop missing values from price column:
data2 = data2.loc[~data["formatted_price"].isnull()]
data2.shape
Out[34]:
In [35]:
# Drop missing values from color column:
data2 = data2.loc[~data["color"].isnull()]
data2.shape
Out[35]:
In [36]:
# Count of duplicates:
data2.duplicated("title").sum()
Out[36]:
In [37]:
# 1-Ignore rows less than 4 words in "title"
# count:
data2['title'].apply(lambda x: len(x.split())<=4).sum()
Out[37]:
In [38]:
# Make list Comp.
data3 = data2[data2['title'].apply(lambda x: len(x.split())>4)]
data3.shape
Out[38]:
In [39]:
# Sort data to compare eachother in title column
data3.sort_values('title',inplace=True, ascending=False)
data3.head()
Out[39]:
In [40]:
# we make here;
# in title column,
# compere 1.row and 2.row than, 2-3, 3-4,.....
# if difference bigger than "2 words",
# we keep them.
duplicates = []
for i in range(len(data3)-1):
#if i < (len(data3)-1): # to provide getting an error:i+1
a = data3['title'].iloc[i].split()
b = data3['title'].iloc[i+1].split()
# keep the maximum length of two strings
length = max(len(a), len(b))
# to keep matches words' count
count = 0
# itertools.zip_longest(a,b): will give [('a','a'), ('b','b'), ('c','d'), ('d', None)]
for k in itertools.zip_longest(a,b):
if k[0] == k[1]:
count += 1
if (length - count) > 2: # number of words in which both sensences differ
# if both strings are differ by more than 2 words we include the 1st string index
duplicates.append(data3['asin'].iloc[i])
#duplicates.append(data3['asin'].iloc[i+1])
In [41]:
# Drop duplicates:
data4 = data3.loc[data['asin'].isin(duplicates)]
In [42]:
data4.shape
Out[42]:
In [43]:
data5 = data4.copy()
In [90]:
indices = []
for i,row in data5.iterrows():
indices.append(i)
In [76]:
# compare sentences and drop lenght<3
duplicates = []
while len(indices)!=0:
i = indices.pop()
duplicates.append(data5['asin'].loc[i])
# consider the first apperal's title
a = data5['title'].loc[i].split()
# store the list of words of ith string in a, ex: a = ['tokidoki', 'The', 'Queen', 'of', 'Diamonds', 'Women's', 'Shirt', 'X-Large']
for j in indices:
b = data5['title'].loc[j].split()
# store the list of words of jth string in b, ex: b = ['tokidoki', 'The', 'Queen', 'of', 'Diamonds', 'Women's', 'Shirt', 'X-Large']
length = max(len(a),len(b))
# count is used to store the number of words that are matched in both strings
count = 0
# itertools.zip_longest(a,b): will map the corresponding words in both strings, it will appened None in case of unequal strings
# example: a =['a', 'b', 'c', 'd']
# b = ['a', 'b', 'd']
# itertools.zip_longest(a,b): will give [('a','a'), ('b','b'), ('c','d'), ('d', None)]
for k in itertools.zip_longest(a,b):
if (k[0]==k[1]):
count += 1
# if the number of words in which both strings differ are < 3 , we are considering it as those two apperals are same, hence we are ignoring them
if (length - count) < 3:
indices.remove(j)
In [512]:
data6 = data5.loc[data['asin'].isin(duplicates)]
In [88]:
data6.shape
Out[88]:
Text Pre-processing¶
Drop The Special Chars¶
In [637]:
# drop the special chars in review like '"#$@!%^&*()_+-~?>< etc.
data6["title"] = data6["title"].str.replace("[^\w\s]","")
data6.head()
Out[637]:
Make Lower Chars¶
In [638]:
# Make lower characters:
data6["title"] = data6["title"].apply(lambda x: " ".join(i.lower() for i in x.split()))
data6.head()
Out[638]:
Drop Stop-Words¶
In [639]:
# Drop Stop-Words:
sw = stopwords.words("english")
data6["title"] = data6["title"].apply(lambda x: " ".join(i for i in x.split() if i not in sw))
data6.head()
Out[639]:
In [642]:
data6.to_pickle("data6")
Stemming¶
In [120]:
#st = PorterStemmer()
In [ ]:
# data6["title"] = data6["title"].apply(lambda x: " ".join(st.stem(word) for word in x))
Count Vector (Bag of Words)¶
In [153]:
vectorizer = CountVectorizer()
vectorizer_title = vectorizer.fit_transform(data6["title"])
In [154]:
vectorizer_title.get_shape()
Out[154]:
Let's Make Prediction with Count Vector¶
- ID : Clothes/t-shirt id / between 0-16367
- num_results : How many predictions do you want to see
In [261]:
def count_model(ID,num_results):
# https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise_distances.html
# Compute the distance matrix from a vector array X and optional Y.
# sklearn.metrics.pairwise.pairwise_distances(X, Y=None, metric='euclidean')
pairwise_distance = pairwise_distances(vectorizer_title,vectorizer_title[ID])
# Returns the indices that would sort an array.
# we make flatten the matris to make in one arary.
indices = np.argsort(pairwise_distance.flatten())[0:num_results]
# hide the smallest euclidean distance
# it was not necessary for prediction, just want to show distance
smallest_distance = np.sort(pairwise_distance.flatten())[0:num_results]
# use indices in dataset to find real positions
df_indices = list(data6.index[indices])
for i in range(len(df_indices)):
print("Title: ",data6['title'].loc[df_indices[i]])
print("Distance",smallest_distance[i])
# take image's url
url = data6['medium_image_url'].loc[df_indices[i]]
response = requests.get(url)
img = Image.open(BytesIO(response.content))
# show image
plt.imshow(img)
plt.show()
In [262]:
# indices: array([ 1354, 1353, 15143, 8171, 7520], dtype=int64)
In [264]:
count_model(15143,5)
In [270]:
count_model(2983,10)
In [274]:
count_model(12920,5)
TF - IDF¶
- words-importance
- TF: Word Freq in title
- IDF: log(total title count / which titles has "word_1" )
- If idf is big, it means "word_1" rare.
In [277]:
# Make Model:
tf_idf_word_vectorizer = TfidfVectorizer()
tf_idf_title = tf_idf_word_vectorizer.fit_transform(data6["title"])
In [287]:
def tf_idf_model(ID,num_results):
# https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise_distances.html
# Compute the distance matrix from a vector array X and optional Y.
# sklearn.metrics.pairwise.pairwise_distances(X, Y=None, metric='euclidean')
pairwise_distance = pairwise_distances(tf_idf_title,tf_idf_title[ID])
# Returns the indices that would sort an array.
# we make flatten the matris to make in one arary.
indices = np.argsort(pairwise_distance.flatten())[0:num_results]
# hide the smallest euclidean distance
# it was not necessary for prediction, just want to show distance
smallest_distance = np.sort(pairwise_distance.flatten())[0:num_results]
# use indices in dataset to find real positions
df_indices = list(data6.index[indices])
for i in range(len(df_indices)):
print("Title: ",data6['title'].loc[df_indices[i]])
print("Distance",smallest_distance[i])
# take image's url
url = data6['medium_image_url'].loc[df_indices[i]]
response = requests.get(url)
img = Image.open(BytesIO(response.content))
# show image
plt.imshow(img)
plt.show()
In [288]:
tf_idf_model(15143,5)
In [281]:
tf_idf_model(2983,10)
In [282]:
tf_idf_model(12920,5)
In [291]:
tf_idf_model(4946,5)
Word2Vec¶
- Use Google News Vectors(Pre-trained ML model)
- Word2vec basically place the word in the feature space is such a way that their location is determined by their meaning i.e. words having similar meaning are clustered together and the distance between two words also have the same meaning.
Cosine Similarity¶
- lets first understand what is cosine similarity because word2vec uses cosine similarity for finding out the most similar word. Cosine similarity is not only telling the similarity between two vectors but it also test for orthogonality of vector
- if angle are close to zero than we can say that vectors are very similar to each other and if theta is 90 than we can say vectors are orthogonal to each other (orthogonal vector not related to each other ) and if theta is 180 we can say that both the vector are opposite to each other.
In [299]:
from gensim.models import Word2Vec
from gensim.models import KeyedVectors
In [301]:
model = KeyedVectors.load_word2vec_format("GoogleNews-vectors-negative300.bin",binary=True)
In [308]:
# count of words
vocab = model.wv.vocab
len(vocab)
Out[308]:
Avg Word2Vector¶
- It tries to learn the relationship between vector automatically from raw text. larger the dimension it has, larger it is rich in information the vector is.
properties:¶
- 1- if word w1 and w2 are similar than vector v1 and v2 will be closer.
- 2- automatic learn the relationship between words/vector.
how to convert each document to vector?¶
- suppose you have w1, w2, …wn word in one document(row). in order to convert into vector.
- each word has one vector, we will convert average word2vec than divide by the number of word in a document.
In [458]:
# create the new word2vec
def w2v_vectorize(x):
sent_vectors = []
coeff = 0
vector = np.zeros((300,))
for word in x.split():
coeff += 1
if word in vocab:
vector += model[word]
if coeff != 0:
vector = vector / coeff
return np.array(vector)
In [459]:
avg_word2vector = []
for i in data6['title']:
avg_word2vector.append(w2v_vectorize(i))
In [460]:
def avg_w2v_model(ID,num_results):
# https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise_distances.html
# Compute the distance matrix from a vector array X and optional Y.
# sklearn.metrics.pairwise.pairwise_distances(X, Y=None, metric='euclidean')
pairwise_distance = pairwise_distances(avg_word2vector,avg_word2vector[ID].reshape(1,-1))
# Returns the indices that would sort an array.
# we make flatten the matris to make in one arary.
indices = np.argsort(pairwise_distance.flatten())[0:num_results]
# hide the smallest euclidean distance
# it was not necessary for prediction, just want to show distance
smallest_distance = np.sort(pairwise_distance.flatten())[0:num_results]
# use indices in dataset to find real positions
df_indices = list(data6.index[indices])
for i in range(len(df_indices)):
print("Title: ",data6['title'].loc[df_indices[i]])
print("Distance",smallest_distance[i])
# take image's url
url = data6['medium_image_url'].loc[df_indices[i]]
response = requests.get(url)
img = Image.open(BytesIO(response.content))
# show image
plt.imshow(img)
plt.show()
In [461]:
avg_w2v_model(1514,10)
In [462]:
avg_w2v_model(3043,10)
In [463]:
avg_w2v_model(12020,5)
In [464]:
avg_w2v_model(4946,10)
TF-IDF Weighted Word2Vec¶
In [478]:
# create the new word2vec
def tfidf_w2v_vectorize(x,ID):
sent_vectors = []
coeff = 0
vector = np.zeros((300,))
for word in x.split():
coeff += 1
if word in vocab and word in tf_idf_word_vectorizer.vocabulary_:
vector += model[word] * tf_idf_title[ID,tf_idf_word_vectorizer.vocabulary_[word]]
if coeff != 0:
vector = vector / coeff
return np.array(vector)
In [479]:
tfidf_word2vector = []
ID = 0
for i in data6['title']:
tfidf_word2vector.append(tfidf_w2v_vectorize(i,ID))
ID += 1
In [469]:
def tfidf_w2v_model(ID,num_results):
# https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise_distances.html
# Compute the distance matrix from a vector array X and optional Y.
# sklearn.metrics.pairwise.pairwise_distances(X, Y=None, metric='euclidean')
pairwise_distance = pairwise_distances(tfidf_word2vector,tfidf_word2vector[ID].reshape(1,-1))
# Returns the indices that would sort an array.
# we make flatten the matris to make in one arary.
indices = np.argsort(pairwise_distance.flatten())[0:num_results]
# hide the smallest euclidean distance
# it was not necessary for prediction, just want to show distance
smallest_distance = np.sort(pairwise_distance.flatten())[0:num_results]
# use indices in dataset to find real positions
df_indices = list(data6.index[indices])
for i in range(len(df_indices)):
print("Title: ",data6['title'].loc[df_indices[i]])
print("Distance",smallest_distance[i])
# take image's url
url = data6['medium_image_url'].loc[df_indices[i]]
response = requests.get(url)
img = Image.open(BytesIO(response.content))
# show image
plt.imshow(img)
plt.show()
In [470]:
tfidf_w2v_model(4946,10)
In [471]:
tfidf_w2v_model(12020,5)
In [472]:
tfidf_w2v_model(3043,10)
In [634]:
tfidf_w2v_model(6677,10)
TF-IDF Weighted Word2Vec For Brand & Color Features¶
In [491]:
data6['brand'].fillna(value="Not given", inplace=True)
In [495]:
# replace spaces with hypen
brands = [x.replace(" ", "-") for x in data6['brand'].values]
colors = [str(x).replace(" ", "-") for x in data6['color'].values]
type_name = [str(x).replace(" ", "-") for x in data6['product_type_name'].values]
In [514]:
# TF-IDF
tf_idf_brands_vectorizer = TfidfVectorizer()
tf_idf_brands = tf_idf_brands_vectorizer.fit_transform(brands)
tf_idf_colors_vectorizer = TfidfVectorizer()
tf_idf_colors = tf_idf_colors_vectorizer.fit_transform(colors)
tf_idf_type_name_vectorizer = TfidfVectorizer()
tf_idf_type_name = tf_idf_type_name_vectorizer.fit_transform(colors)
In [515]:
color_brand = hstack((tf_idf_brands, tf_idf_colors,tf_idf_type_name)).tocsr()
In [516]:
def tf_idf_color_brand_model(ID,num_results,w1,w2):
# w1: weight for tfidf
# w2: weight for color&brand features
# https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise_distances.html
# Compute the distance matrix from a vector array X and optional Y.
# sklearn.metrics.pairwise.pairwise_distances(X, Y=None, metric='euclidean')
tfidf_distance = pairwise_distances(tfidf_word2vector,tfidf_word2vector[ID].reshape(1,-1))
color_brand_distance = pairwise_distances(color_brand,color_brand[ID])
pairwise_distance = (w1 * tfidf_distance + w2 * color_brand_distance)/float(w1 + w2)
# Returns the indices that would sort an array.
# we make flatten the matris to make in one arary.
indices = np.argsort(pairwise_distance.flatten())[0:num_results]
# hide the smallest euclidean distance
# it was not necessary for prediction, just want to show distance
smallest_distance = np.sort(pairwise_distance.flatten())[0:num_results]
# use indices in dataset to find real positions
df_indices = list(data6.index[indices])
for i in range(len(df_indices)):
print("Title: ",data6['title'].loc[df_indices[i]])
print("Distance",smallest_distance[i])
# take image's url
url = data6['medium_image_url'].loc[df_indices[i]]
response = requests.get(url)
img = Image.open(BytesIO(response.content))
# show image
plt.imshow(img)
plt.show()
In [633]:
tf_idf_color_brand_model(10877,10,1,100)
In [518]:
tf_idf_color_brand_model(10877,10,100,1)
In [521]:
tf_idf_color_brand_model(15143,10,1,1)
In [522]:
tf_idf_color_brand_model(15143,10,1,100)
In [523]:
tf_idf_color_brand_model(12920,10,1,100)
In [538]:
import tensorflow.keras
import pandas as pd
import sklearn as sk
import tensorflow as tf
import numpy as np
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dropout, Flatten, Dense
from tensorflow.keras import applications
from sklearn.metrics import pairwise_distances
import matplotlib.pyplot as plt
import requests
from PIL import Image
import pandas as pd
import pickle
Use Pre-Trained Models¶
In [546]:
# VGG16 models without the classifier part of the model by specifying the “include_top” argument to “False”,
model = applications.VGG16(weights='imagenet', include_top=False)
model.summary()
In [566]:
#Function to compute VGG-16 CNN for image feature extraction
# dimensions of our images.
img_width, img_height = 224, 224
top_model_weights_path = 'bottleneck_fc_model.h5'
train_data_dir = '16k_images/'
nb_train_samples = 16032
epochs = 50
batch_size = 1
def feature_exract():
asins = []
datagen = ImageDataGenerator(rescale=1. / 255)
generator = datagen.flow_from_directory(
train_data_dir,
target_size=(img_width, img_height),
batch_size=batch_size,
class_mode=None,
shuffle=False)
for i in generator.filenames: # take labels
asins.append(i[2:-5])
cnn_features = model.predict_generator(generator, nb_train_samples // batch_size)
cnn_features = cnn_features.reshape((nb_train_samples,25088))
np.save(open('cnn_features.npy', 'wb'), cnn_features)
np.save(open('cnn_feature_asins.npy', 'wb'), np.array(asins))
In [585]:
#load the features and corresponding ASINS info.
cnn_features = np.load('cnn_features.npy')
cnn_feature_asins = np.load('cnn_feature_asins.npy')
cnn_feature_asins = list(cnn_feature_asins)
In [586]:
# load the original 16K dataset
df_asins = list(data6['asin'])
In [635]:
def cnn(ID,num_results):
doc_id = asins.index(df_asins[ID])
# https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise_distances.html
# Compute the distance matrix from a vector array X and optional Y.
# sklearn.metrics.pairwise.pairwise_distances(X, Y=None, metric='euclidean')
pairwise_distance = pairwise_distances(cnn_features,cnn_features[ID].reshape(1,-1))
# Returns the indices that would sort an array.
# we make flatten the matris to make in one arary.
indices = np.argsort(pairwise_distance.flatten())[0:num_results]
# hide the smallest euclidean distance
# it was not necessary for prediction, just want to show distance
smallest_distance = np.sort(pairwise_distance.flatten())[0:num_results]
# use indices in dataset to find real positions
df_indices = list(data6.index[indices])
for i in range(len(df_indices)):
rows = data6[['medium_image_url','title']].loc[data6['asin']==asins[indices[i]]]
for indx, row in rows.iterrows():
print("Title: ",row['title'])
print("Distance",smallest_distance[i])
# take image's url
url = row['medium_image_url']
response = requests.get(url)
img = Image.open(BytesIO(response.content))
# show image
plt.imshow(img)
plt.show()
In [636]:
cnn(12530,10)
In [625]:
cnn(7766,10)
In [627]:
cnn(6677,10)
In [628]:
cnn(9933,10)
In [629]:
cnn(3399,10)
Combine Models¶
- Combination of weighted vector [text + (brand + color) + image] is used to get similar products.
In [643]:
def combine_models(ID,num_results,w1,w2,w3):
# w1: weight for tfidf
# w2: weight for color&brand features
# w3: cnn weight
# https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise_distances.html
# Compute the distance matrix from a vector array X and optional Y.
# sklearn.metrics.pairwise.pairwise_distances(X, Y=None, metric='euclidean')
tf_idf_distance = pairwise_distances(tf_idf_title,tf_idf_title[ID])
color_brand_distance = pairwise_distances(color_brand,color_brand[ID])
cnn_distance = pairwise_distances(cnn_features,cnn_features[ID].reshape(1,-1))
#
pairwise_distance = (w1 * tf_idf_distance + w2 * color_brand_distance + w3 * cnn_distance)/float(w1 + w2 + w3)
# Returns the indices that would sort an array.
# we make flatten the matris to make in one arary.
indices = np.argsort(pairwise_distance.flatten())[0:num_results]
# hide the smallest euclidean distance
# it was not necessary for prediction, just want to show distance
smallest_distance = np.sort(pairwise_distance.flatten())[0:num_results]
# use indices in dataset to find real positions
df_indices = list(data6.index[indices])
for i in range(len(df_indices)):
print("Title: ",data6['title'].loc[df_indices[i]])
print("Distance",smallest_distance[i])
# take image's url
url = data6['medium_image_url'].loc[df_indices[i]]
response = requests.get(url)
img = Image.open(BytesIO(response.content))
# show image
plt.imshow(img)
plt.show()